package com.mroapp.utils;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串操作工具包
 * 
 * @author gefufeng
 * @version 1.0
 * @created 2012-3-21
 */
public class StringUtils {
	private final static Pattern emailer = Pattern
			.compile("\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*");
	private final static SimpleDateFormat dateFormater = new SimpleDateFormat(
			"yyyy-MM-dd HH:mm:ss");
	private final static SimpleDateFormat dateFormater2 = new SimpleDateFormat(
			"yyyy-MM-dd");

	/**
	 * 判断字符是否为空
	 * 
	 * @param str
	 * @return
	 */
	public static boolean isBlank(String str) {
		return (str == null || str.trim().length() == 0);
	}

	/**
	 * 将字符串转位日期类型
	 * 
	 * @param sdate
	 * @return
	 */
	public static Date toDate(String sdate) {
		try {
			return dateFormater.parse(sdate);
		} catch (ParseException e) {
			return null;
		}
	}

	/**
	 * 过滤电话号码
	 * 
	 * @param mobile
	 */
	public static String replaceMobile(String mobile) {
		if (mobile == null) {
			return null;
		}
		mobile = replace(" ", "", mobile);
		mobile = replace("+", "", mobile);
		mobile = replace("-", "", mobile);
		if (mobile.startsWith("01")) {
			if (!mobile.startsWith("010")) {
				mobile = mobile.substring(1, mobile.length());
			}
		}
		if (mobile.startsWith("86")) {
			mobile = mobile.substring(2, mobile.length());
		}
		return mobile;
	}

	/**
	 * 功能描述：判断输入的字符串是否大于等于6，小于等于18
	 * 
	 * @param str
	 *            传入的字符窜
	 * @return 如果是符合则返回true,否则返回false
	 */
	public static boolean isLength(String str) {
		int length = str.length();
		if (length >= 6 && length <= 18) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 功能描述：替换字符串
	 * 
	 * @param from
	 *            String 原始字符串
	 * @param to
	 *            String 目标字符串
	 * @param source
	 *            String 母字符串
	 * @return String 替换后的字符串
	 */
	public static String replace(String from, String to, String source) {
		if (source == null || from == null || to == null)
			return null;
		StringBuffer str = new StringBuffer("");
		int index = -1;
		while ((index = source.indexOf(from)) != -1) {
			str.append(source.substring(0, index) + to);
			source = source.substring(index + from.length());
			index = source.indexOf(from);
		}
		str.append(source);
		return str.toString();
	}

	/**
	 * 以友好的方式显示时间
	 * 
	 * @param sdate
	 * @return
	 */
	public static String friendly_time(Date time) {
		if (time == null) {
			return "Unknown";
		}
		String ftime = "";
		Calendar cal = Calendar.getInstance();

		// 判断是否是同一天
		String curDate = dateFormater2.format(cal.getTime());
		String paramDate = dateFormater2.format(time);
		if (curDate.equals(paramDate)) {
			int hour = (int) ((cal.getTimeInMillis() - time.getTime()) / 3600000);
			if (hour == 0)
				ftime = Math.max(
						(cal.getTimeInMillis() - time.getTime()) / 60000, 1)
						+ "分钟前";
			else
				ftime = hour + "小时前";
			return ftime;
		}

		long lt = time.getTime() / 86400000;
		long ct = cal.getTimeInMillis() / 86400000;
		int days = (int) (ct - lt);
		if (days == 0) {
			int hour = (int) ((cal.getTimeInMillis() - time.getTime()) / 3600000);
			if (hour == 0)
				ftime = Math.max(
						(cal.getTimeInMillis() - time.getTime()) / 60000, 1)
						+ "分钟前";
			else
				ftime = hour + "小时前";
		} else if (days == 1) {
			ftime = "昨天";
		} else if (days == 2) {
			ftime = "前天";
		} else if (days > 2 && days <= 10) {
			ftime = days + "天前";
		} else if (days > 10) {
			ftime = dateFormater2.format(time);
		}
		return ftime;
	}

	/**
	 * 判断给定字符串时间是否为今日
	 * 
	 * @param sdate
	 * @return boolean
	 */
	public static boolean isToday(String sdate) {
		boolean b = false;
		Date time = toDate(sdate);
		Date today = new Date();
		if (time != null) {
			String nowDate = dateFormater2.format(today);
			String timeDate = dateFormater2.format(time);
			if (nowDate.equals(timeDate)) {
				b = true;
			}
		}
		return b;
	}

	/**
	 * 判断给定字符串是否空白串。 空白串是指由空格、制表符、回车符、换行符组成的字符串 若输入字符串为null或空字符串，返回true
	 * 
	 * @param input
	 * @return boolean
	 */
	public static boolean isEmpty(String input) {
		if (input == null || "".equals(input) || "null".equals(input))
			return true;

		for (int i = 0; i < input.length(); i++) {
			char c = input.charAt(i);
			if (c != ' ' && c != '\t' && c != '\r' && c != '\n') {
				return false;
			}
		}
		return true;
	}

	/**
	 * 判断是不是一个合法的电子邮件地址
	 * 
	 * @param email
	 * @return
	 */
	public static boolean isEmail(String email) {
		if (email == null || email.trim().length() == 0)
			return false;
		return emailer.matcher(email).matches();
	}

	/**
	 * 字符串转整数
	 * 
	 * @param str
	 * @param defValue
	 * @return
	 */
	public static int toInt(String str, int defValue) {
		try {
			return Integer.parseInt(str);
		} catch (Exception e) {
		}
		return defValue;
	}

	/**
	 * 对象转整数
	 * 
	 * @param obj
	 * @return 转换异常返回 0
	 */
	public static int toInt(Object obj) {
		if (obj == null)
			return 0;
		return toInt(obj.toString(), 0);
	}

	/**
	 * 对象转整数
	 * 
	 * @param obj
	 * @return 转换异常返回 0
	 */
	public static long toLong(String obj) {
		try {
			return Long.parseLong(obj);
		} catch (Exception e) {
		}
		return 0;
	}

	/**
	 * 字符串转布尔值
	 * 
	 * @param b
	 * @return 转换异常返回 false
	 */
	public static boolean toBool(String b) {
		try {
			return Boolean.parseBoolean(b);
		} catch (Exception e) {
		}
		return false;
	}

	/**
	 * 把距离转友好的显示
	 * 
	 * @param distance
	 *            单位为m的距离
	 * @return
	 */
	public static String friendlyDistance(double distance) {
		if (distance <= 0) {
			return "10米内";
		}
		// 距离显示方式：100——900米内、1公里内、2公里内、20——100公里内（10公里一个间隔）、100——1000公里内（100公里一个间隔）、1000公里外（此数据为运营确认数据，请尽量实现）
		if (distance > 100) {
			if (distance < 900) {
				return ((int) (Math.floor(distance / 100) * 100)) + 100 + "米内";
			} else if (distance < 20 * 1000) {
				return ((int) (Math.floor(distance / 1000))) + 1 + "公里内";
			} else if (distance < 100 * 1000) {// 10公里一个间隔
				return ((int) (Math.floor(distance / (1000 * 10)))) + 1
						+ "0公里内";
			} else if (distance < 1000 * 1000) {// 10公里一个间隔
				return ((int) (Math.floor(distance / (1000 * 100)))) + 1
						+ "00公里内";
			} else {
				return "1000公里外";
			}
		} else {
			return 100 + "米内";
		}
	}

	/**
	 * 电话号码验证 最大输入11位
	 * 
	 * @param mobiles
	 *            电话号码
	 * @return 满足条件返回 true
	 */
	public static boolean phoneValidate(String mobiles) {
		// String regEx =
		// "(^[0-9]{3,4}[0-9]{3,8}$)|^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|2|3|5|6|7|8|9])\\d{8}$";
		String regEx = "1[3,4,5,8,7]{1}\\d{9}";
		// String regEx =
		// "(^[1]{3,4}[0-9]{3,8}$)|^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|2|3|5|6|7|8|9])\\d{8}$";
		return validateString(mobiles, regEx);
	}

	/**
	 * 密码验证 数字字母6-18 位
	 * 
	 * @param password
	 *            密码
	 * @return 满足条件返回 true
	 */
	public static boolean passwordValidate(String password) {
		String regEx = "^[a-zA-Z0-9]{6,18}$";// 这里是正则表达式
		boolean b = validateString(password, regEx);
		return b;
	}

	/**
	 * 网址
	 * 
	 * @param url
	 * @return
	 */
	public static boolean urlValidate(String url) {
		String regEx = "^http.*$";// 这里是正则表达式
		// String regEx =
		// "^http://([\\w]+(\\.[\\w]+)+(/[\\w.\\/\\?%&=\u4e00-\u9fa5]*)?)?$";//这里是正则表达式
		return validateString(url, regEx);
	}

	/**
	 * 拓拓
	 * 
	 * @param url
	 * @return
	 */
	public static boolean ttUrlValidate(String url) {
		String regEx = "http://www.tuotuo.im/mobile(/\\d+){2}";// 这里是正则表达式
		return validateString(url, regEx);
	}

	public static boolean apkValidate(String url) {
		String regEx = "^.*\\.apk$";// 这里是正则表达式
		return validateString(url, regEx);
	}

	/**
	 * 签名 36 个全角字符
	 */
	public static boolean signValidate(String sign) {
		String regEx = "";// 这里是正则表达式
		return validateString(sign, regEx);
	}

	/**
	 * 昵称9个全角
	 */
	// public static boolean nicknameValidate(String nickname){
	// String regEx = "";//这里是正则表达式
	// return validateString(nickname,regEx);
	// }
	/**
	 * 充值卡号19位 recharge
	 */
	// public static boolean rechargeValidate(String nickname){
	// String regEx = "";//这里是正则表达式
	// return validateString(nickname,regEx);
	// }
	/**
	 * 序列号18位
	 * 
	 */

	/**
	 * 拓拓号码 数字 不能少于六位
	 */
	public static boolean ttNumValidate(String ttNum) {
		String regEx = "^.{6,}$";// 这里是正则表达式
		return validateString(ttNum, regEx);
	}

	/**
	 * 充值密码
	 * 
	 */

	/**
	 * 字符验证
	 * 
	 * @param str
	 *            需要验证的字符
	 * @param regEx
	 *            正则表达式
	 * @return 满足条件返回true
	 */
	private static boolean validateString(String str, String regEx) {
		Pattern p = Pattern.compile(regEx);
		Matcher m = p.matcher(str);
		return m.matches();
	}

	/**
	 * 截取指定路径
	 * 
	 * @param fullPath
	 * @param fileName
	 * @return
	 */
	public static String getBucketPath(String fullPath, String fileName) {

		if(fullPath.lastIndexOf(fileName)>0){
			return fullPath.substring(0, fullPath.lastIndexOf(fileName));
		}
		return fullPath.substring(0, 0);
	}

	public static boolean isNull(String str) {
		if (str == null || str.trim().length() == 0) {
			return true;
		}
		return false;
	}
	/**
	 * 计算两个经纬度之间的距离
	 */
	private static final double EARTH_RADIUS = 6378137.0; 
	 // 返回单位是千米  
	 public static double getDistance(double longitude1, double latitude1,  
	   double longitude2, double latitude2) {  
	  double Lat1 = rad(latitude1);  
	  double Lat2 = rad(latitude2);  
	  double a = Lat1 - Lat2;  
	  double b = rad(longitude1) - rad(longitude2);  
	  double s = 2 * Math.asin(Math.sqrt(Math.pow(Math.sin(a / 2), 2)  
	    + Math.cos(Lat1) * Math.cos(Lat2)  
	    * Math.pow(Math.sin(b / 2), 2)));  
	  s = s * EARTH_RADIUS;  
	  s = Math.round(s * 10000) / 10000;  
	  return s / 1000;  
	 }  
	 private static double rad(double d) {  
	  return d * Math.PI / 180.0;  
	 }  
}